#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
MySQL数据库语言检测脚本
从tg_group表读取title字段，识别语言并存入language字段
"""


# cd /home/python
# source venv_check/bin/activate


# nohup python3 mysql_lang_check.py > output.log 2>&1 &
# ps aux | grep mysql_lang_check
# kill 459354
# tail -f output.log

import mysql.connector
import logging
import time
import sys
from typing import Dict, Optional, Tuple
from datetime import datetime
import argparse
import configparser
import os

# 语言检测库
try:
    import langid
    LANGID_AVAILABLE = True
except ImportError:
    LANGID_AVAILABLE = False
    print("警告: langid库未安装，请运行: pip install langid")

# =============================================================================
# SQL查询语句常量区域
# =============================================================================
# 
# 当前配置：
# - 表名: tg_group
# - ID范围: < 687160
# - 业务类型: 0
# - 数据源类型: 1
# - 删除标记: 0 (未删除)

# SQL查询语句
SQL_SELECT_RECORDS = """
SELECT id, title 
FROM `tg_group` 
WHERE id < 687160
AND business_type = 0
AND data_source_type = 1
AND is_del = 0
ORDER BY id
LIMIT %s OFFSET %s
"""

SQL_COUNT_RECORDS = """
SELECT COUNT(*) 
FROM `tg_group` 
WHERE id < 687160
AND business_type = 0
AND data_source_type = 1
AND is_del = 0
"""

SQL_UPDATE_LANGUAGE = """
UPDATE `tg_group` 
SET language = %s, 
    region = %s
WHERE id = %s
"""

class MySQLLanguageDetector:
    """
    MySQL数据库语言检测器
    """
    
    def __init__(self, db_config: Dict):
        """
        初始化数据库连接
        """
        self.db_config = db_config
        self.connection = None
        self.cursor = None
        
        
        # 设置日志
        self.setup_logging()
        
        # 初始化langid
        if LANGID_AVAILABLE:
            self.init_langid()
        
        # 语言代码 -> 中文名称映射
        self.language_names = {
            'en': '英文', 'zh': '中文', 'zh-cn': '中文', 'zh-tw': '中文', 'zh-hk': '中文', 'zh-sg': '中文',
            'fr': '法文', 'de': '德文', 'es': '西班牙文', 'ru': '俄文', 'ja': '日文', 'ko': '韩文', 
            'ar': '阿拉伯文', 'pt': '葡萄牙文', 'it': '意大利文', 'nl': '荷兰文', 'sv': '瑞典文', 
            'da': '丹麦文', 'no': '挪威文', 'fi': '芬兰文', 'pl': '波兰文', 'tr': '土耳其文', 
            'th': '泰文', 'vi': '越南文', 'id': '印尼文', 'ms': '马来文', 'hi': '印地文', 
            'bn': '孟加拉文', 'ur': '乌尔都文', 'fa': '波斯文', 'he': '希伯来文', 'el': '希腊文', 
            'cs': '捷克文', 'hu': '匈牙利文', 'ro': '罗马尼亚文', 'bg': '保加利亚文', 
            'hr': '克罗地亚文', 'sk': '斯洛伐克文', 'sl': '斯洛文尼亚文', 'et': '爱沙尼亚文', 
            'lv': '拉脱维亚文', 'lt': '立陶宛文', 'uk': '乌克兰文', 'be': '白俄罗斯文', 
            'ka': '格鲁吉亚文', 'hy': '亚美尼亚文', 'az': '阿塞拜疆文', 'kk': '哈萨克文', 
            'ky': '吉尔吉斯文', 'uz': '乌兹别克文', 'tg': '塔吉克文', 'mn': '蒙古文', 
            'my': '缅甸文', 'km': '高棉文', 'lo': '老挝文', 'si': '僧伽罗文', 'ne': '尼泊尔文', 
            'gu': '古吉拉特文', 'pa': '旁遮普文', 'ta': '泰米尔文', 'te': '泰卢固文', 
            'ml': '马拉雅拉姆文', 'kn': '卡纳达文', 'or': '奥里亚文', 'as': '阿萨姆文', 
            'mr': '马拉地文', 'sa': '梵文', 'bo': '藏文', 'dz': '宗卡文', 'ti': '提格雷文', 
            'am': '阿姆哈拉文', 'sw': '斯瓦希里文', 'zu': '祖鲁文', 'af': '南非荷兰文', 
            'sq': '阿尔巴尼亚文', 'eu': '巴斯克文', 'ca': '加泰罗尼亚文', 'cy': '威尔士文', 
            'ga': '爱尔兰文', 'is': '冰岛文', 'mt': '马耳他文', 'mk': '马其顿文', 
            'sr': '塞尔维亚文', 'bs': '波斯尼亚文', 'me': '黑山文',
            'unknown': '未知'
        }
        
        # 语言 -> 国家/地区映射（具体到国家）
        self.language_to_region = {
            # 东亚
            'zh': '中国', 'zh-cn': '中国', 'zh-tw': '中国台湾', 'zh-hk': '中国香港', 'zh-sg': '新加坡',
            'ja': '日本', 'ko': '韩国', 'mn': '蒙古',
            
            # 东南亚
            'th': '泰国', 'vi': '越南', 'id': '印度尼西亚', 'ms': '马来西亚', 
            'my': '缅甸', 'km': '柬埔寨', 'lo': '老挝', 'tl': '菲律宾',
            
            # 南亚
            'hi': '印度', 'bn': '孟加拉国', 'ur': '巴基斯坦', 'si': '斯里兰卡', 'ne': '尼泊尔',
            'gu': '印度', 'pa': '印度/巴基斯坦', 'ta': '印度/斯里兰卡', 'te': '印度', 'ml': '印度',
            'kn': '印度', 'or': '印度', 'as': '印度', 'mr': '印度', 'sa': '印度',
            'bo': '中国西藏', 'dz': '不丹',
            
            # 西欧
            'en': '英美/全球', 'fr': '法国', 'de': '德国', 'es': '西班牙', 'pt': '葡萄牙',
            'it': '意大利', 'nl': '荷兰', 'sv': '瑞典', 'da': '丹麦', 'no': '挪威',
            'fi': '芬兰', 'is': '冰岛', 'ga': '爱尔兰', 'cy': '威尔士', 'eu': '西班牙',
            'ca': '西班牙',
            
            # 东欧
            'ru': '俄罗斯', 'pl': '波兰', 'uk': '乌克兰', 'be': '白俄罗斯', 'cs': '捷克',
            'hu': '匈牙利', 'ro': '罗马尼亚', 'bg': '保加利亚', 'hr': '克罗地亚', 'sk': '斯洛伐克',
            'sl': '斯洛文尼亚', 'et': '爱沙尼亚', 'lv': '拉脱维亚', 'lt': '立陶宛', 'mk': '北马其顿',
            'sr': '塞尔维亚', 'bs': '波黑', 'me': '黑山', 'sq': '阿尔巴尼亚',
            
            # 中东
            'ar': '阿拉伯世界', 'fa': '伊朗', 'he': '以色列', 'tr': '土耳其',
            
            # 中亚/高加索
            'ka': '格鲁吉亚', 'hy': '亚美尼亚', 'az': '阿塞拜疆', 'kk': '哈萨克斯坦', 
            'ky': '吉尔吉斯斯坦', 'uz': '乌兹别克斯坦', 'tg': '塔吉克斯坦',
            
            # 非洲
            'am': '埃塞俄比亚', 'sw': '肯尼亚/坦桑尼亚', 'zu': '南非', 'af': '南非', 'ti': '埃塞俄比亚',
            
            # 南欧
            'el': '希腊', 'mt': '马耳他',
            
            # 未知
            'unknown': '未知'
        }
    
    def init_langid(self):
        """
        初始化langid语言检测
        """
        try:
            # langid不需要额外的模型文件，直接可用
            self.logger.info("langid初始化成功")
        except Exception as e:
            self.logger.error(f"langid初始化失败: {e}")
    
    def setup_logging(self):
        """
        设置日志配置 - 同时输出到文件和控制台
        """
        # 创建logs目录
        log_dir = 'logs'
        if not os.path.exists(log_dir):
            os.makedirs(log_dir)
        
        # 生成带时间戳的日志文件名
        log_filename = os.path.join(
            log_dir, 
            f'language_detection_{datetime.now().strftime("%Y%m%d_%H%M%S")}.log'
        )
        
        # 配置日志格式
        log_format = '%(asctime)s - %(levelname)s - %(message)s'
        date_format = '%Y-%m-%d %H:%M:%S'
        
        # 清除现有的handlers（避免重复日志）
        for handler in logging.root.handlers[:]:
            logging.root.removeHandler(handler)
        
        # 配置日志处理器
        logging.basicConfig(
            level=logging.INFO,
            format=log_format,
            datefmt=date_format,
            handlers=[
                # 文件处理器 - 详细日志
                logging.FileHandler(log_filename, encoding='utf-8', mode='w'),
                # 控制台处理器 - 简化输出
                logging.StreamHandler(sys.stdout)
            ]
        )
        
        self.logger = logging.getLogger(__name__)
        self.logger.info(f"日志文件: {log_filename}")
    
    
    def connect_database(self) -> bool:
        """
        连接数据库
        """
        try:
            self.connection = mysql.connector.connect(**self.db_config)
            self.cursor = self.connection.cursor(buffered=True)
            self.logger.info("数据库连接成功")
            return True
        except mysql.connector.Error as e:
            self.logger.error(f"数据库连接失败: {e}")
            return False
    
    def close_database(self):
        """
        关闭数据库连接
        """
        if self.cursor:
            self.cursor.close()
        if self.connection:
            self.connection.close()
        self.logger.info("数据库连接已关闭")
    
    def preprocess_text_for_detection(self, text: str) -> str:
        """
        预处理文本以提高语言检测准确性
        """
        import re
        
        # 移除过多的表情符号和特殊字符
        # 保留基本的文字内容
        processed = re.sub(r'[🎯🔥💎🌟⭐🎊🎉🎈🎁🎀🌹🌸🌺🌻🌷💐🌼🌿🍀🌱🌳🌲🎄🌴🌵🌾🌿]', ' ', text)
        processed = re.sub(r'[📱📞📟📠☎️📧📨📩📤📥📦📫📪📬📭📮🗳️]', ' ', processed)
        processed = re.sub(r'[⚡🔋🔌💡🔦🕯️🪔🧯🛢️💸💰💴💵💶💷💳💎⚖️🔧🔨⚒️🛠️⛏️🔩⚙️🧰🧲🔫]', ' ', processed)
        
        # 移除过多的重复字符
        processed = re.sub(r'(.)\1{3,}', r'\1\1', processed)
        
        # 移除多余的空白字符
        processed = re.sub(r'\s+', ' ', processed)
        
        # 移除URL和@mentions
        processed = re.sub(r'http[s]?://\S+', ' ', processed)
        processed = re.sub(r'@\w+', ' ', processed)
        
        return processed.strip()
    
    def postprocess_language_detection(self, original_text: str, languages: list, confidences: list) -> Tuple[str, float]:
        """
        后处理语言检测结果，基于文本特征进行优化
        """
        import re
        
        if not languages or not confidences:
            return 'unknown', 0.0
        
        # 基于字符集的语言判断
        char_based_lang = self.detect_language_by_charset(original_text)
        
        # 如果字符集检测有明确结果，且在候选列表中，优先考虑
        if char_based_lang and char_based_lang in languages:
            char_index = languages.index(char_based_lang)
            # 如果字符集匹配的语言置信度不是太低，就使用它
            if confidences[char_index] > 0.1:
                return char_based_lang, confidences[char_index]
        
        # 特殊规则处理
        top_lang = languages[0]
        top_conf = confidences[0]
        
        # 如果检测为日语但文本中没有日语字符，检查是否为其他语言
        if top_lang == 'ja':
            if not re.search(r'[\u3040-\u309F\u30A0-\u30FF\u4E00-\u9FAF]', original_text):
                # 检查是否为阿拉伯语或波斯语
                if re.search(r'[\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF\uFB50-\uFDFF\uFE70-\uFEFF]', original_text):
                    if 'fa' in languages:
                        return 'fa', confidences[languages.index('fa')]
                    elif 'ar' in languages:
                        return 'ar', confidences[languages.index('ar')]
                
                # 如果有其他更合理的选择
                if len(languages) > 1 and confidences[1] > 0.3:
                    return languages[1], confidences[1]
        
        # 中文检测优化
        if re.search(r'[\u4e00-\u9fff]', original_text):
            if 'zh' in languages:
                return 'zh', confidences[languages.index('zh')]
            elif top_lang not in ['zh', 'zh-cn']:
                # 如果有中文字符但没检测为中文，降低置信度
                top_conf = max(0.1, top_conf * 0.5)
        
        return top_lang, top_conf
    
    def detect_language_by_charset(self, text: str) -> str:
        """
        基于字符集检测语言
        """
        import re
        
        # 中文字符
        if re.search(r'[\u4e00-\u9fff]', text):
            return 'zh'
        
        # 阿拉伯语字符
        if re.search(r'[\u0600-\u06FF]', text):
            # 区分阿拉伯语和波斯语
            # 波斯语特有字符
            if re.search(r'[\u067E\u0686\u0698\u06AF]', text):
                return 'fa'
            return 'ar'
        
        # 日语字符
        if re.search(r'[\u3040-\u309F\u30A0-\u30FF]', text):
            return 'ja'
        
        # 韩语字符
        if re.search(r'[\uAC00-\uD7AF]', text):
            return 'ko'
        
        # 俄语字符
        if re.search(r'[\u0400-\u04FF]', text):
            return 'ru'
        
        # 希腊语字符
        if re.search(r'[\u0370-\u03FF]', text):
            return 'el'
        
        return None
    
    def detect_language_langid(self, text: str) -> Tuple[str, float]:
        """
        使用langid检测语言，带预处理和后处理优化
        """
        if not LANGID_AVAILABLE or not text or len(text.strip()) < 3:
            return 'unknown', 0.0
        
        try:
            # 文本预处理
            processed_text = self.preprocess_text_for_detection(text)
            
            # langid预测
            language, confidence = langid.classify(processed_text)
            
            # 后处理优化 - 基于字符集验证结果
            final_lang, final_conf = self.postprocess_language_detection(
                text, [language], [confidence]
            )
            
            return final_lang, final_conf
                
        except Exception as e:
            self.logger.warning(f"langid检测失败: {e}")
            return 'unknown', 0.0
    
    def detect_language_combined(self, text: str) -> Dict:
        """
        使用langid检测语言
        """
        if not text or len(text.strip()) == 0:
            return {
                'language': 'unknown',
                'confidence': 0.0,
                'method': 'none'
            }
        
        # 使用langid检测语言
        lang_id, conf_id = self.detect_language_langid(text)
        
        if lang_id != 'unknown':
            return {
                'language': lang_id,
                'confidence': conf_id,
                'method': 'langid'
            }
        else:
            return {
                'language': 'unknown',
                'confidence': 0.0,
                'method': 'failed'
            }
    
    def detect_language(self, text: str) -> Dict:
        """
        检测语言的主方法（调用综合检测方法）
        """
        return self.detect_language_combined(text)
    
    def get_records_to_process(self, batch_size: int = 1000, offset: int = 0) -> list:
        """
        获取需要处理的记录
        
        Args:
            batch_size: 批处理大小
            offset: 偏移量
        """
        try:
            # 使用全局SQL常量
            self.cursor.execute(SQL_SELECT_RECORDS, (batch_size, offset))
            records = self.cursor.fetchall()
            
            return records
            
        except mysql.connector.Error as e:
            self.logger.error(f"查询记录失败: {e}")
            return []
    
    def get_region_from_language(self, language: str) -> str:
        """
        根据语言获取地区
        """
        return self.language_to_region.get(language, '未知')
    
    def update_language(self, record_id: int, language: str, confidence: float, method: str) -> bool:
        """
        更新记录的语言和地区字段
        """
        try:
            # 获取对应的地区
            region = self.get_region_from_language(language)
            
            values = (
                language,
                region,
                record_id
            )
            
            self.cursor.execute(SQL_UPDATE_LANGUAGE, values)
            self.connection.commit()
            
            return True
            
        except mysql.connector.Error as e:
            self.logger.error(f"更新记录 {record_id} 失败: {e}")
            return False
    
    def process_batch(self, batch_size: int, offset: int) -> Tuple[int, int]:
        """
        处理一批记录
        返回(处理数量, 更新数量)
        """
        # 获取记录
        records = self.get_records_to_process(batch_size, offset)
        
        if not records:
            return 0, 0
        
        first_id = records[0][0]
        last_record_id = records[-1][0]
        self.logger.info(f"开始处理 ID {first_id} - {last_record_id}，共 {len(records)} 条记录")
        
        processed = 0
        updated = 0
        
        for record in records:
            try:
                record_id, title = record
                
                # 检测语言
                result = self.detect_language(title)
                
                if not result:
                    processed += 1
                    continue
                
                language = result['language']
                confidence = result['confidence']
                method = result['method']
                
                # 更新数据库
                if self.update_language(record_id, language, confidence, method):
                    updated += 1
                    
                    # 记录检测结果
                    lang_name = self.language_names.get(language, language)
                    region = self.get_region_from_language(language)
                    self.logger.info(
                        f"ID {record_id}: '{title[:50]}...' -> {language} ({lang_name}) "
                        f"地区: {region} [{confidence:.3f}] via {method}"
                    )
                else:
                    self.logger.error(f"更新记录 {record_id} 失败")
                
                processed += 1
                
                # 每100条记录休息一下，避免过载
                if processed % 100 == 0:
                    time.sleep(0.1)
                    
            except Exception as e:
                self.logger.error(f"处理记录 {record_id} 时出错: {e}")
                processed += 1
                continue
        
        self.logger.info(f"批次处理完成: 处理 {processed} 条，更新 {updated} 条")
        return processed, updated
    
    def get_total_count(self) -> int:
        """
        获取需要处理的总记录数
        """
        try:
            # 使用全局SQL常量
            self.cursor.execute(SQL_COUNT_RECORDS)
            result = self.cursor.fetchone()
            return result[0] if result else 0
            
        except mysql.connector.Error as e:
            self.logger.error(f"获取总数失败: {e}")
            return 0
    
    def run_detection(self, batch_size: int = 1000, max_records: int = None):
        """
        运行语言检测任务
        
        Args:
            batch_size: 批处理大小
            max_records: 最大处理记录数
        """
        if not self.connect_database():
            return
        
        try:
            # 获取总记录数
            total_count = self.get_total_count()
            self.logger.info(f"数据库总记录数: {total_count}")
            
            if total_count == 0:
                self.logger.info("没有需要处理的记录")
                return
            
            # 限制处理数量
            target_count = max_records if max_records else total_count
            self.logger.info(f"本次计划处理: {target_count} 条记录")
            
            # 分批处理
            total_processed = 0
            total_updated = 0
            current_offset = 0
            
            start_time = time.time()
            
            while total_processed < target_count:
                # 计算本批次大小
                remaining = target_count - total_processed
                current_batch_size = min(batch_size, remaining)
                
                processed, updated = self.process_batch(current_batch_size, current_offset)
                
                if processed == 0:
                    self.logger.info("没有更多记录需要处理")
                    break
                
                total_processed += processed
                total_updated += updated
                current_offset += processed
                
                # 显示进度
                progress = (total_processed / target_count) * 100
                elapsed_time = time.time() - start_time
                avg_speed = total_processed / elapsed_time if elapsed_time > 0 else 0
                
                self.logger.info(
                    f"进度: {total_processed}/{target_count} ({progress:.1f}%) "
                    f"已更新: {total_updated} 用时: {elapsed_time:.1f}s 速度: {avg_speed:.1f}条/秒"
                )
                
                # 短暂休息
                time.sleep(0.5)
            
            # 完成统计
            total_time = time.time() - start_time
            avg_speed = total_processed / total_time if total_time > 0 else 0
            self.logger.info(
                f"语言检测完成! 总处理: {total_processed} 条，总更新: {total_updated} 条，"
                f"总用时: {total_time:.1f}s，平均: {avg_speed:.1f} 条/秒"
            )
            
        except KeyboardInterrupt:
            self.logger.info(f"用户中断程序")
        except Exception as e:
            self.logger.error(f"程序执行出错: {e}")
        finally:
            self.close_database()


def setup_main_logging():
    """
    设置主程序日志（在创建检测器之前）
    """
    # 创建logs目录
    log_dir = 'logs'
    if not os.path.exists(log_dir):
        os.makedirs(log_dir)
    
    # 生成带时间戳的日志文件名
    log_filename = os.path.join(
        log_dir, 
        f'language_detection_{datetime.now().strftime("%Y%m%d_%H%M%S")}.log'
    )
    
    # 配置日志格式
    log_format = '%(asctime)s - %(levelname)s - %(message)s'
    date_format = '%Y-%m-%d %H:%M:%S'
    
    # 清除现有的handlers
    for handler in logging.root.handlers[:]:
        logging.root.removeHandler(handler)
    
    # 配置日志
    logging.basicConfig(
        level=logging.INFO,
        format=log_format,
        datefmt=date_format,
        handlers=[
            logging.FileHandler(log_filename, encoding='utf-8', mode='w'),
            logging.StreamHandler(sys.stdout)
        ]
    )
    
    logger = logging.getLogger('main')
    logger.info("=" * 60)
    logger.info("MySQL语言检测脚本")
    logger.info(f"日志文件: {log_filename}")
    logger.info("=" * 60)
    
    return logger

def load_config_from_file(config_file='config.ini'):
    """
    从配置文件加载配置
    """
    if not os.path.exists(config_file):
        return None
    
    config = configparser.ConfigParser()
    config.read(config_file, encoding='utf-8')
    
    db_config = {}
    if config.has_section('database'):
        db_config = {
            'host': config.get('database', 'host', fallback='localhost'),
            'port': config.getint('database', 'port', fallback=3306),
            'user': config.get('database', 'user'),
            'password': config.get('database', 'password'),
            'database': config.get('database', 'database'),
            'charset': 'utf8mb4',
            'autocommit': False
        }
    
    batch_size = 1000
    if config.has_section('detection'):
        batch_size = config.getint('detection', 'batch_size', fallback=1000)
    
    return db_config, batch_size

def main():
    """
    主函数
    """
    parser = argparse.ArgumentParser(
        description='MySQL数据库语言检测脚本',
        epilog='如果不提供命令行参数，将从config.ini读取配置'
    )
    parser.add_argument('--config', default='config.ini', help='配置文件路径')
    parser.add_argument('--host', help='数据库主机（覆盖配置文件）')
    parser.add_argument('--port', type=int, help='数据库端口（覆盖配置文件）')
    parser.add_argument('--user', help='数据库用户名（覆盖配置文件）')
    parser.add_argument('--password', help='数据库密码（覆盖配置文件）')
    parser.add_argument('--database', help='数据库名（覆盖配置文件）')
    parser.add_argument('--batch-size', type=int, help='批处理大小（覆盖配置文件）')
    parser.add_argument('--max-records', type=int, help='最大处理记录数（用于测试）')
    
    args = parser.parse_args()
    
    # 设置日志
    logger = setup_main_logging()
    
    # 尝试从配置文件加载
    config_data = load_config_from_file(args.config)
    
    if config_data:
        db_config, batch_size = config_data
        logger.info(f"已从 {args.config} 加载配置")
    else:
        # 配置文件不存在，使用命令行参数
        if not all([args.user, args.password, args.database]):
            logger.error("错误: 配置文件不存在，必须提供 --user, --password, --database 参数")
            sys.exit(1)
        
        db_config = {
            'host': args.host or 'localhost',
            'port': args.port or 3306,
            'user': args.user,
            'password': args.password,
            'database': args.database,
            'charset': 'utf8mb4',
            'autocommit': False
        }
        batch_size = args.batch_size or 1000
        logger.info("使用命令行参数配置")
    
    # 命令行参数覆盖配置文件
    if args.host:
        db_config['host'] = args.host
    if args.port:
        db_config['port'] = args.port
    if args.user:
        db_config['user'] = args.user
    if args.password:
        db_config['password'] = args.password
    if args.database:
        db_config['database'] = args.database
    if args.batch_size:
        batch_size = args.batch_size
    
    # 检查必要的库
    if not LANGID_AVAILABLE:
        logger.error("错误: langid库未安装，请运行: pip install langid")
        sys.exit(1)
    
    # 显示配置信息
    logger.info(f"数据库配置: {db_config['user']}@{db_config['host']}:{db_config['port']}/{db_config['database']}")
    logger.info(f"批处理大小: {batch_size}")
    if args.max_records:
        logger.info(f"最大处理记录数: {args.max_records}")
    logger.info("")
    
    # 创建检测器并运行
    detector = MySQLLanguageDetector(db_config)
    detector.run_detection(batch_size, args.max_records)

if __name__ == "__main__":
    main()
